home *** CD-ROM | disk | FTP | other *** search
/ Games of Daze / Infomagic - Games of Daze (Summer 1995) (Disc 1 of 2).iso / djgpp / contrib / pdcurs22 / src / portable / addstr.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-01-26  |  8.5 KB  |  294 lines
  1. /*
  2. ***************************************************************************
  3. * This file comprises part of PDCurses. PDCurses is Public Domain software.
  4. * You may use this code for whatever purposes you desire. This software
  5. * is provided AS IS with NO WARRANTY whatsoever.
  6. * Should this software be used in another application, an acknowledgement
  7. * that PDCurses code is used would be appreciated, but is not mandatory.
  8. *
  9. * Any changes which you make to this software which may improve or enhance
  10. * it, should be forwarded to the current maintainer for the benefit of 
  11. * other users.
  12. *
  13. * The only restriction placed on this code is that no distribution of
  14. * modified PDCurses code be made under the PDCurses name, by anyone
  15. * other than the current maintainer.
  16. * 
  17. * See the file maintain.er for details of the current maintainer.
  18. ***************************************************************************
  19. */
  20. #define    CURSES_LIBRARY    1
  21. #include <curses.h>
  22.  
  23. /* undefine any macros for functions defined in this module */
  24. #undef    addstr
  25. #undef    addnstr
  26. #undef    waddstr
  27. #undef    waddnstr
  28. #undef    mvaddstr
  29. #undef    mvaddnstr
  30. #undef    mvwaddstr
  31. #undef    mvwaddnstr
  32.  
  33. /* undefine any macros for functions called by this module if in debug mode */
  34. #ifdef PDCDEBUG
  35. #  undef    move
  36. #  undef    wmove
  37. #  undef    addch
  38. #  undef    waddch
  39. #endif
  40.  
  41. #ifdef PDCDEBUG
  42. char *rcsid_addstr  = "$Id$";
  43. #endif
  44.  
  45. /*man-start*********************************************************************
  46.  
  47.   Name:                                                        addstr
  48.  
  49.   Synopsis:
  50.       int addstr(char *str);
  51.       int addnstr(char *str, int n);
  52.       int waddstr(WINDOW *win, char *str);
  53.       int waddnstr(WINDOW *win, char *str, int n);
  54.       int mvaddstr(int y, int x, char *str);
  55.       int mvaddnstr(int y, int x, char *str, int n);
  56.       int mvwaddstr(WINDOW *, int y, int x, char *str);
  57.       int mvwaddnstr(WINDOW *, int y, int x, char *str, int n);
  58.  
  59.   X/Open Description:
  60.      These routines write all the characters of the null-terminated
  61.      string str on the given window.  The functionality is equivalent
  62.      to calling waddch() once for each character in the string.  The four
  63.      routines with n as the last argument write at most n characters.  If n
  64.      is negative, then the entire string will be added.
  65.  
  66.      NOTE:    addstr(), mvaddstr(), and mvwaddstr() are implemented as macros.
  67.          addnstr(), mvaddnstr(), and mvwaddnstr() are implemented as macros.
  68.  
  69.   PDCurses Description:
  70.      The *raw*() routines output 8 bit values.  These contrast to their
  71.      normal counterparts which output 7 bit values and convert control
  72.      character to the ^X notation.
  73.  
  74.      str is a standard 8 bit character string WITHOUT embedded attributes.
  75.  
  76.   X/Open Return Value:
  77.      All functions return OK on success and ERR on error.
  78.  
  79.   X/Open Errors:
  80.      No errors are defined for this function.
  81.  
  82.   Portability                             X/Open    BSD    SYS V
  83.                                           Dec '88
  84.       addstr                                Y        Y       Y
  85.       waddstr                               Y        Y       Y
  86.       mvaddstr                              Y        Y       Y
  87.       mvwaddstr                             Y        Y       Y
  88.       addnstr                               -        -      4.0
  89.       waddnstr                              -        -      4.0
  90.       mvaddnstr                             -        -      4.0
  91.       mvwaddnstr                            -        -      4.0
  92.  
  93. **man-end**********************************************************************/
  94.  
  95. /***********************************************************************/
  96. int    addstr(char *str)
  97. /***********************************************************************/
  98. {
  99.     int i;
  100. #ifdef PDCDEBUG
  101.     if (trace_on) PDC_debug("addstr() - called: string=\"%s\"\n",str);
  102. #endif
  103.  
  104.     if (stdscr == (WINDOW *)NULL)
  105.         return( ERR );
  106.  
  107.     while (*str)
  108.     {
  109.         if ((i = *str++)<0) i += 256;  /* make negative chars positive - PJK */
  110.         if (PDC_chadd( stdscr, (chtype)i, (bool)(!(_cursvar.raw_out)), TRUE ) == ERR)
  111.         {
  112.             return( ERR );
  113.         }
  114.     }
  115.     return( OK );
  116. }
  117. /***********************************************************************/
  118. int    addnstr(char *str, int n)
  119. /***********************************************************************/
  120. {
  121.     int ic = 0;
  122.     int i;
  123. #ifdef PDCDEBUG
  124.     if (trace_on) PDC_debug("addnstr() - called: string=\"%s\" n %d \n",str,n);
  125. #endif
  126.  
  127.     if (stdscr == (WINDOW *)NULL)
  128.         return( ERR );
  129.  
  130.     while ( *str && (ic < n || n < 0) )
  131.     {
  132.         if ((i = *str++)<0) i += 256;  /* make negative chars positive - PJK */
  133.         if (PDC_chadd( stdscr, (chtype)i, (bool)(!(_cursvar.raw_out)), TRUE ) == ERR)
  134.         {
  135.             return( ERR );
  136.         }
  137.         ic++;
  138.     }
  139.     return( OK );
  140. }
  141. /***********************************************************************/
  142. int    waddstr(WINDOW *win, char *str)
  143. /***********************************************************************/
  144. {
  145.     int i;
  146. #ifdef PDCDEBUG
  147.     if (trace_on) PDC_debug("waddstr() - called: string=\"%s\"\n",str);
  148. #endif
  149.  
  150.     if (win == (WINDOW *)NULL)
  151.         return( ERR );
  152.  
  153.     while (*str)
  154.     {
  155.         if ((i = *str++)<0) i += 256;  /* make negative chars positive - PJK */
  156.         if (PDC_chadd( win, (chtype)i, (bool)(!(_cursvar.raw_out)), TRUE ) == ERR)
  157.         {
  158.             return( ERR );
  159.         }
  160.     }
  161.     return( OK );
  162. }
  163. /***********************************************************************/
  164. int    waddnstr(WINDOW *win, char *str, int n)
  165. /***********************************************************************/
  166. {
  167.     int ic = 0;
  168.     int i;
  169.  
  170. #ifdef PDCDEBUG
  171.     if (trace_on) PDC_debug("waddnstr() - called: string=\"%s\" n %d \n",str,n);
  172. #endif
  173.  
  174.     if (win == (WINDOW *)NULL)
  175.         return( ERR );
  176.  
  177.     while ( *str && (ic < n || n < 0) )
  178.     {
  179.         if ((i = *str++)<0) i += 256;  /* make negative chars positive - PJK */
  180.         if (PDC_chadd( win, (chtype)i, (bool)(!(_cursvar.raw_out)), TRUE ) == ERR)
  181.         {
  182.             return( ERR );
  183.         }
  184.         ic++;
  185.     }
  186.     return( OK );
  187. }
  188. /***********************************************************************/
  189. int    mvaddstr(int y, int x, char *str)
  190. /***********************************************************************/
  191. {
  192.     int i;
  193. #ifdef PDCDEBUG
  194.     if (trace_on) PDC_debug("mvaddstr() - called: y %d x %d string=\"%s\"\n",y,x,str);
  195. #endif
  196.  
  197.     if (stdscr == (WINDOW *)NULL)
  198.         return( ERR );
  199.  
  200.     if (wmove(stdscr,y,x) == ERR)
  201.         return( ERR );
  202.  
  203.     while (*str)
  204.     {     
  205.         if ((i = *str++)<0) i += 256;  /* make negative chars positive - PJK */
  206.         if (PDC_chadd( stdscr, (chtype)i, (bool)(!(_cursvar.raw_out)), TRUE ) == ERR)
  207.         {
  208.             return( ERR );
  209.         }
  210.     }
  211.     return( OK );
  212. }
  213. /***********************************************************************/
  214. int    mvaddnstr(int y, int x, char *str, int n)
  215. /***********************************************************************/
  216. {
  217.     int ic = 0;
  218.     int i;
  219.  
  220. #ifdef PDCDEBUG
  221.     if (trace_on) PDC_debug("mvaddnstr() - called: y %d x %d string=\"%s\" n %d \n",y,x,str,n);
  222. #endif
  223.  
  224.     if (stdscr == (WINDOW *)NULL)
  225.         return( ERR );
  226.  
  227.     if (wmove(stdscr,y,x) == ERR)
  228.         return( ERR );
  229.  
  230.     while ( *str && (ic < n || n < 0) )
  231.     {                
  232.         if ((i = *str++)<0) i += 256;  /* make negative chars positive - PJK */
  233.         if (PDC_chadd( stdscr, (chtype)i, (bool)(!(_cursvar.raw_out)), TRUE ) == ERR)
  234.         {
  235.             return( ERR );
  236.         }
  237.         ic++;
  238.     }
  239.     return( OK );
  240. }
  241. /***********************************************************************/
  242. int    mvwaddstr(WINDOW *win, int y, int x, char *str)
  243. /***********************************************************************/
  244. {
  245.     int i;
  246. #ifdef PDCDEBUG
  247.     if (trace_on) PDC_debug("waddstr() - called: string=\"%s\"\n",str);
  248. #endif
  249.  
  250.     if (win == (WINDOW *)NULL)
  251.         return( ERR );
  252.  
  253.     if (wmove(win,y,x) == ERR)
  254.         return( ERR );
  255.  
  256.     while (*str)
  257.     {     
  258.         if ((i = *str++)<0) i += 256;  /* make negative chars positive - PJK */
  259.         if (PDC_chadd( win, (chtype)i, (bool)(!(_cursvar.raw_out)), TRUE ) == ERR)
  260.         {
  261.             return( ERR );
  262.         }
  263.     }
  264.     return( OK );
  265. }
  266. /***********************************************************************/
  267. int    mvwaddnstr(WINDOW *win,int y, int x, char *str, int n)
  268. /***********************************************************************/
  269. {
  270.     int ic = 0;
  271.     int i;
  272.  
  273. #ifdef PDCDEBUG
  274.     if (trace_on) PDC_debug("mvwaddnstr() - called: y %d x %d string=\"%s\" n %d \n",y,x,str,n);
  275. #endif
  276.  
  277.     if (win == (WINDOW *)NULL)
  278.         return( ERR );
  279.  
  280.     if (wmove(win,y,x) == ERR)
  281.         return( ERR );
  282.  
  283.     while ( *str && (ic < n || n < 0) )
  284.     {     
  285.         if ((i = *str++)<0) i += 256;  /* make negative chars positive - PJK */
  286.         if (PDC_chadd( win, (chtype)i, (bool)(!(_cursvar.raw_out)), TRUE ) == ERR)
  287.         {
  288.             return( ERR );
  289.         }
  290.         ic++;
  291.     }
  292.     return( OK );
  293. }
  294.